/*
 * Copyright 2018 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkContourMeasure_DEFINED
#define SkContourMeasure_DEFINED

#include "include/core/SkPoint.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/private/base/SkAPI.h"
#include "include/private/base/SkTDArray.h"

#include <memory>

class SkMatrix;
class SkPath;

class SK_API SkContourMeasure : public SkRefCnt {
public:
    /* * Return the length of the contour.
     */
    SkScalar length() const
    {
        return fLength;
    }

    /* * Pins distance to 0 <= distance <= length(), and then computes the corresponding
     * position and tangent.
     */
    [[nodiscard]] bool getPosTan(SkScalar distance, SkPoint *position, SkVector *tangent) const;

    enum MatrixFlags {
        kGetPosition_MatrixFlag = 0x01,
        kGetTangent_MatrixFlag = 0x02,
        kGetPosAndTan_MatrixFlag = kGetPosition_MatrixFlag | kGetTangent_MatrixFlag
    };

    /* * Pins distance to 0 <= distance <= getLength(), and then computes
     the corresponding matrix (by calling getPosTan).
     Returns false if there is no path, or a zero-length path was specified, in which case
     matrix is unchanged.
     */
    [[nodiscard]] bool getMatrix(SkScalar distance, SkMatrix *matrix,
        MatrixFlags flags = kGetPosAndTan_MatrixFlag) const;

    /* * Given a start and stop distance, return in dst the intervening segment(s).
     If the segment is zero-length, return false, else return true.
     startD and stopD are pinned to legal values (0..getLength()). If startD > stopD
     then return false (and leave dst untouched).
     Begin the segment with a moveTo if startWithMoveTo is true
     */
    [[nodiscard]] bool getSegment(SkScalar startD, SkScalar stopD, SkPath *dst, bool startWithMoveTo) const;

    /* * Return true if the contour is closed()
     */
    bool isClosed() const
    {
        return fIsClosed;
    }

private:
    struct Segment {
        SkScalar fDistance; // total distance up to this point
        unsigned fPtIndex;  // index into the fPts array
        unsigned fTValue : 30;
        unsigned fType : 2; // actually the enum SkSegType
        // See SkPathMeasurePriv.h

        SkScalar getScalarT() const;

        static const Segment *Next(const Segment *seg)
        {
            unsigned ptIndex = seg->fPtIndex;
            do {
                ++seg;
            } while (seg->fPtIndex == ptIndex);
            return seg;
        }
    };

    const SkTDArray<Segment> fSegments;
    const SkTDArray<SkPoint> fPts; // Points used to define the segments

    const SkScalar fLength;
    const bool fIsClosed;

    SkContourMeasure(SkTDArray<Segment> &&segs, SkTDArray<SkPoint> &&pts, SkScalar length, bool isClosed);
    ~SkContourMeasure() override {}

    const Segment *distanceToSegment(SkScalar distance, SkScalar *t) const;

    friend class SkContourMeasureIter;
    friend class SkPathMeasurePriv;
};

class SK_API SkContourMeasureIter {
public:
    SkContourMeasureIter();
    /* *
     * Initialize the Iter with a path.
     * The parts of the path that are needed are copied, so the client is free to modify/delete
     * the path after this call.
     *
     * resScale controls the precision of the measure. values > 1 increase the
     * precision (and possibly slow down the computation).
     */
    SkContourMeasureIter(const SkPath &path, bool forceClosed, SkScalar resScale = 1);
    ~SkContourMeasureIter();

    SkContourMeasureIter(SkContourMeasureIter &&);
    SkContourMeasureIter &operator = (SkContourMeasureIter &&);

    /* *
     * Reset the Iter with a path.
     * The parts of the path that are needed are copied, so the client is free to modify/delete
     * the path after this call.
     */
    void reset(const SkPath &path, bool forceClosed, SkScalar resScale = 1);

    /* *
     * Iterates through contours in path, returning a contour-measure object for each contour
     * in the path. Returns null when it is done.
     *
     * This only returns non-zero length contours, where a contour is the segments between
     * a kMove_Verb and either ...
     * - the next kMove_Verb
     * - kClose_Verb (1 or more)
     * - kDone_Verb
     * If it encounters a zero-length contour, it is skipped.
     */
    sk_sp<SkContourMeasure> next();

private:
    class Impl;

    std::unique_ptr<Impl> fImpl;
};

#endif
